{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# An Introduction to the Scientific Python Ecosystem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the Python language is an excellent tool for general-purpose programming, with a highly readable syntax, rich and powerful data types (strings, lists, sets, dictionaries, arbitrary length integers, etc) and a very comprehensive standard library, it was not designed specifically for mathematical and scientific computing.  Neither the language nor its standard library have facilities for the efficient representation of multidimensional datasets, tools for linear algebra and general matrix manipulations (an essential building block of virtually all technical computing), nor any data visualization facilities.\n",
    "\n",
    "In particular, Python lists are very flexible containers that can be nested arbitrarily deep and which can hold any Python object in them, but they are poorly suited to represent efficiently common mathematical constructs like vectors and matrices.  In contrast, much of our modern heritage of scientific computing has been built on top of libraries written in the Fortran language, which has native support for vectors and matrices as well as a library of mathematical functions that can efficiently operate on entire arrays at once.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scientific Python: a collaboration of projects built by scientists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scientific community has developed a set of related Python libraries that provide powerful array facilities, linear algebra, numerical algorithms, data visualization and more.  In this appendix, we will briefly outline the tools most frequently used for this purpose, that make \"Scientific Python\" something far more powerful than the Python language alone.\n",
    "\n",
    "For reasons of space, we can only briefly describe the central Numpy library, but below we provide links to the websites of each project where you can read their full documentation in more detail.\n",
    "\n",
    "First, let's look at an overview of the basic tools that most scientists use in daily research with Python.  The core of this ecosystem is composed of:\n",
    "\n",
    "* **Numpy:** the basic library that most others depend on, it provides a powerful array type that can represent multidimensional datasets of many different kinds and that supports arithmetic operations. Numpy also provides a library of common mathematical functions, basic linear algebra, random number generation and Fast Fourier Transforms.  Numpy can be found at [numpy.scipy.org](http://numpy.scipy.org)\n",
    "\n",
    "* **Scipy:** a large collection of numerical algorithms that operate on numpy arrays and provide facilities for many common tasks in scientific computing, including dense and sparse linear algebra, optimization, special functions, statistics, n-dimensional image processing, signal processing and more. Scipy can be found at [scipy.org](http://scipy.org).\n",
    "\n",
    "* **Matplotlib:** a data visualization library with a strong focus on producing high-quality output, it supports a variety of common scientific plot types in two and three dimensions, with precise control over the final output for publication-quality results.  Matplotlib can also be controlled interactively allowing graphical manipulation of your data (zooming, panning). It can be found at [matplotlib.org](http://matplotlib.org).\n",
    "\n",
    "* **IPython:** while not restricted to scientific uses, IPython is the interactive environment in which many scientists spend their time when working with the Python language. IPython provides a powerful Python shell that integrates tightly with Matplotlib and with easy access to the files and operating system, as well as components for high-level parallel computing.  It can execute either in a terminal or in a graphical Qt console. IPython also has a web-based notebook interface that can combine code with text, mathematical expressions, figures and multimedia.  It can be found at [ipython.org](http://ipython.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Motivation: the trapezoidal rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In subsequent sections we'll provide a basic introduction to the nuts and bolts of the basic scientific python tools; but we'll first motivate it with a brief example that illustrates what you can do in a few lines with these tools.  For this, we will use the simple problem of approximating a definite integral with the trapezoid rule:\n",
    "\n",
    "$$\n",
    "\\int_{a}^{b} f(x)\\, dx \\approx \\frac{1}{2} \\sum_{k=1}^{N} \\left( x_{k} - x_{k-1} \\right) \\left( f(x_{k}) + f(x_{k-1}) \\right).\n",
    "$$\n",
    "\n",
    "Our task will be to compute this formula for a function such as:\n",
    "\n",
    "$$\n",
    "f(x) = (x-3)(x-5)(x-7)+85\n",
    "$$\n",
    "\n",
    "integrated between $a=1$ and $b=9$.\n",
    "\n",
    "First, we define the function and sample it evenly between 0 and 10 at 200 points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return (x-3)*(x-5)*(x-7)+85\n",
    "\n",
    "import numpy as np\n",
    "x = np.linspace(0, 10, 200)\n",
    "y = f(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We select $a$ and $b$, our integration limits, and we take only a few points in that region to illustrate the error behavior of the trapezoid approximation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 1, 9\n",
    "sampling = 10\n",
    "xint = x[np.logical_and(x>=a, x<=b)][::sampling]\n",
    "yint = y[np.logical_and(x>=a, x<=b)][::sampling]\n",
    "# Fix end points of the interval\n",
    "xint[0], xint[-1] = a, b\n",
    "yint[0], yint[-1] = f(a), f(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot both the function and the area below it in the trapezoid approximation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-dark')\n",
    "\n",
    "plt.plot(x, y, lw=2)\n",
    "plt.plot([a, a], [0, f(a)], color='black')\n",
    "plt.plot([b, b], [0, f(b)], color='black')\n",
    "plt.axis([a-1, b+1, 0, 140])\n",
    "plt.fill_between(xint, 0, yint, facecolor='gray', edgecolor='red', alpha=.4)\n",
    "plt.text(0.5 * (a + b), 30,r\"$\\int_a^b f(x)dx$\", horizontalalignment='center', fontsize=20);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the integral both at high accuracy and with the trapezoid approximation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The integral is: 680 +/- 7.5e-12\n",
      "The trapezoid approximation with 16 points is: 681.1247978745048\n",
      "The absolute error is: 1.124797874504793\n"
     ]
    }
   ],
   "source": [
    "from scipy.integrate import quad, trapz\n",
    "\n",
    "integral, error = quad(f, a, b)\n",
    "trap_integral = trapz(yint, xint)\n",
    "print(\"The integral is: %g +/- %.1e\" % (integral, error))\n",
    "print(\"The trapezoid approximation with\", len(xint), \"points is:\", trap_integral)\n",
    "print(\"The absolute error is:\", abs(integral - trap_integral))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This simple example showed us how, combining the numpy, scipy and matplotlib libraries we can provide an illustration of a standard method in elementary calculus with just a few lines of code.  We will now discuss with more detail the basic usage of these tools.\n",
    "\n",
    "A note on visual styles: matplotlib has a rich system for controlling the visual style of all plot elements. [This page](https://tonysyu.github.io/raw_content/matplotlib-style-gallery/gallery.html) is a gallery that illustrates how each style choice affects different plot types, which you can use to select the most appropriate to your needs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy arrays: the right data structure for scientific computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics of Numpy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now turn our attention to the Numpy library, which forms the base layer for the entire 'scipy ecosystem'.  Once you have installed numpy, you can import it as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "though in this book we will use the common shorthand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned above, the main object provided by numpy is a powerful array.  We'll start by exploring how the numpy array differs from Python lists.  We start by creating a simple list and an array with the same contents of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [10, 20, 30, 40]\n",
    "arr = np.array([10, 20, 30, 40])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements of a one-dimensional array are accessed with the same syntax as a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 40])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first difference to note between lists and arrays is that arrays are *homogeneous*; i.e. all elements of an array must be of the same type.  In contrast, lists can contain elements of arbitrary type. For example, we can change the last element in our list above to be a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 'a string inside a list']"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst[-1] = 'a string inside a list'\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but the same can not be done with an array, as we get an error message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'a string inside an array'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-119-9c0e43e56d9a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'a string inside an array'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'a string inside an array'"
     ]
    }
   ],
   "source": [
    "arr[-1] = 'a string inside an array'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The information about the type of an array is contained in its *dtype* attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once an array has been created, its dtype is fixed and it can only store elements of the same type.  For this example where the dtype is integer, if we store a floating point number it will be automatically converted into an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, -2])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[-1] = round(-1.99999)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we created an array from an existing list; now let us now see other ways in which we can create arrays, which we'll illustrate next.  A common need is to have an array initialized with a constant value, and very often this value is 0 or 1 (suitable as starting value for additive and multiplicative loops respectively); `zeros` creates arrays of all zeros, with any desired dtype:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5, float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.+0.j, 0.+0.j, 0.+0.j])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3, complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and similarly for `ones`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 ones: [1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print('5 ones:', np.ones(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want an array initialized with an arbitrary value, we can create an empty array and then use the fill method to put the value we want into the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 5.5, 5.5, 5.5])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.empty(4)\n",
    "a.fill(5.5)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This illustrates the internal structure of a Numpy array (taken from the [official Numpy docs](https://docs.scipy.org/doc/numpy-1.13.0/reference/arrays.html):\n",
    "\n",
    "<img src=\"numpy_object.png\", width=60%></img>\n",
    "\n",
    "Numpy also offers the `arange` function, which works like the builtin `range` but returns an array instead of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81,\n",
       "       86, 91, 96])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 100, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the `linspace` and `logspace` functions to create linearly and logarithmically-spaced grids respectively, with a fixed number of points and including both ends of the specified interval:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A linear grid between 0 and 1: [0.   0.25 0.5  0.75 1.  ]\n",
      "A logarithmic grid between 10**1 and 10**4:  [   10.   100.  1000. 10000.]\n"
     ]
    }
   ],
   "source": [
    "print(\"A linear grid between 0 and 1:\", np.linspace(0, 1, 5))\n",
    "print(\"A logarithmic grid between 10**1 and 10**4: \", np.logspace(1, 4, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, it is often useful to create arrays with random numbers that follow a specific distribution.  The `np.random` module contains a number of functions that can be used to this effect, for example this will produce an array of 5 random samples taken from a standard normal distribution (0 mean and variance 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.52516852,  0.69942646,  0.41452757, -0.60884852, -1.10460922])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "whereas this will also give 5 samples, but from a normal distribution with a mean of 10 and a variance of 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11.92491263, 13.14525739,  9.53279697,  6.70065794,  7.12572063])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm10 = np.random.normal(10, 3, 5)\n",
    "norm10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing with other arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we saw how to index arrays with single numbers and slices, just like Python lists.  But arrays allow for a more sophisticated kind of indexing which is very powerful: you can index an array with another array, and in particular with an array of boolean values.  This is particluarly useful to extract information from an array that matches a certain condition.\n",
    "\n",
    "Consider for example that in the array `norm10` we want to replace all values above 9 with the value 0.  We can do so by first finding the *mask* that indicates where this condition is true or false:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True, False, False])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = norm10 > 9\n",
    "mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have this mask, we can use it to either read those values or to reset them to 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values above 9: [11.92491263 13.14525739  9.53279697]\n"
     ]
    }
   ],
   "source": [
    "print('Values above 9:', norm10[mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resetting all values above 9 to 0...\n",
      "[9.         9.         9.         6.70065794 7.12572063]\n"
     ]
    }
   ],
   "source": [
    "print('Resetting all values above 9 to 0...')\n",
    "norm10[mask] = 9\n",
    "print(norm10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays with more than one dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Up until now all our examples have used one-dimensional arrays.  But Numpy can create arrays of aribtrary dimensions, and all the methods illustrated in the previous section work with more than one dimension.  For example, a list of lists can be used to initialize a two dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst2 = [[1, 2], [3, 4]]\n",
    "arr2 = np.array([[1, 2], [3, 4]])\n",
    "arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With two-dimensional arrays we start seeing the power of numpy: while a nested list can be indexed using repeatedly the `[ ]` operator, multidimensional arrays support a much more natural indexing syntax with a single `[ ]` and a set of indices separated by commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(lst2[0][1])\n",
    "print(arr2[0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the array creation functions listed above can be used with more than one dimension, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1,2,3],[4,5,6]], order='F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.14191108, 10.29559176, 13.42106936, 15.94217371],\n",
       "       [ 7.44509759,  7.06643839, 10.54550556, 10.48374276]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(10, 3, (2, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, the shape of an array can be changed at any time, as long as the total number of elements is unchanged.  For example, if we want a 2x4 array with numbers increasing from 0, the easiest way to create it is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3]\n",
      " [4 5 6 7]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(8).reshape(2,4)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With multidimensional arrays, you can also use slices, and you can mix and match slices and single indices in the different dimensions (using the same array as above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slicing in the second row: [6 7]\n",
      "All rows, third column   : [2 6]\n"
     ]
    }
   ],
   "source": [
    "print('Slicing in the second row:', arr[1, 2:4])\n",
    "print('All rows, third column   :', arr[:, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you only provide one index, then you will get an array with one less dimension containing that row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row:   [0 1 2 3]\n",
      "Second row:  [4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "print('First row:  ', arr[0])\n",
    "print('Second row: ', arr[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following provides a visual overview of indexing in Numpy:\n",
    "\n",
    "<img src=\"img/numpy_indexing.png\" width=60%>\n",
    "\n",
    "Now that we have seen how to create arrays with more than one dimension, it's a good idea to look at some of the most useful properties and methods that arrays have.  The following provide basic information about the size, shape and data in the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type                : int64\n",
      "Total number of elements : 8\n",
      "Number of dimensions     : 2\n",
      "Shape (dimensionality)   : (2, 4)\n",
      "Memory used (in bytes)   : 64\n"
     ]
    }
   ],
   "source": [
    "print('Data type                :', arr.dtype)\n",
    "print('Total number of elements :', arr.size)\n",
    "print('Number of dimensions     :', arr.ndim)\n",
    "print('Shape (dimensionality)   :', arr.shape)\n",
    "print('Memory used (in bytes)   :', arr.nbytes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays also have many useful methods, some especially useful ones are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum and maximum             : 0 7\n",
      "Sum and product of all elements : 28 0\n",
      "Mean and standard deviation     : 3.5 2.29128784747792\n"
     ]
    }
   ],
   "source": [
    "print('Minimum and maximum             :', arr.min(), arr.max())\n",
    "print('Sum and product of all elements :', arr.sum(), arr.prod())\n",
    "print('Mean and standard deviation     :', arr.mean(), arr.std())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For these methods, the above operations area all computed on all the elements of the array.  But for a multidimensional array, it's possible to do the computation along a single dimension, by passing the `axis` parameter; for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For the following array:\n",
      " [[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "The sum of elements along the rows is    : [ 6 22]\n",
      "The sum of elements along the columns is : [ 4  6  8 10]\n"
     ]
    }
   ],
   "source": [
    "print('For the following array:\\n', arr)\n",
    "print('The sum of elements along the rows is    :', arr.sum(axis=1))\n",
    "print('The sum of elements along the columns is :', arr.sum(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see in this example, the value of the `axis` parameter is the dimension which will be *consumed* once the operation has been carried out.  This is why to sum along the rows we use `axis=0`.  \n",
    "\n",
    "This can be easily illustrated with an example that has more dimensions; we create an array with 4 dimensions and shape `(3,4,5,6)` and sum along the axis number 2 (i.e. the *third* axis, since in Python all counts are 0-based).  That consumes the dimension whose length was 5, leaving us with a new array that has shape `(3,4,6)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4, 6)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,4,5,6)).sum(2).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another widely used property of arrays is the `.T` attribute, which allows you to access the transpose of the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array:\n",
      " [[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "Transpose:\n",
      " [[0 4]\n",
      " [1 5]\n",
      " [2 6]\n",
      " [3 7]]\n"
     ]
    }
   ],
   "source": [
    "print('Array:\\n', arr)\n",
    "print('Transpose:\\n', arr.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't have time here to look at all the methods and properties of arrays, here's a complete list.  Simply try exploring some of these IPython to learn more, or read their description in the full Numpy documentation:\n",
    "\n",
    "    arr.T             arr.copy          arr.getfield      arr.put           arr.squeeze\n",
    "    arr.all           arr.ctypes        arr.imag          arr.ravel         arr.std\n",
    "    arr.any           arr.cumprod       arr.item          arr.real          arr.strides\n",
    "    arr.argmax        arr.cumsum        arr.itemset       arr.repeat        arr.sum\n",
    "    arr.argmin        arr.data          arr.itemsize      arr.reshape       arr.swapaxes\n",
    "    arr.argsort       arr.diagonal      arr.max           arr.resize        arr.take\n",
    "    arr.astype        arr.dot           arr.mean          arr.round         arr.tofile\n",
    "    arr.base          arr.dtype         arr.min           arr.searchsorted  arr.tolist\n",
    "    arr.byteswap      arr.dump          arr.nbytes        arr.setasflat     arr.tostring\n",
    "    arr.choose        arr.dumps         arr.ndim          arr.setfield      arr.trace\n",
    "    arr.clip          arr.fill          arr.newbyteorder  arr.setflags      arr.transpose\n",
    "    arr.compress      arr.flags         arr.nonzero       arr.shape         arr.var\n",
    "    arr.conj          arr.flat          arr.prod          arr.size          arr.view\n",
    "    arr.conjugate     arr.flatten       arr.ptp           arr.sort          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Returns the indices of the maximum values along an axis.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "a : array_like\n",
       "    Input array.\n",
       "axis : int, optional\n",
       "    By default, the index is into the flattened array, otherwise\n",
       "    along the specified axis.\n",
       "out : array, optional\n",
       "    If provided, the result will be inserted into this array. It should\n",
       "    be of the appropriate shape and dtype.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "index_array : ndarray of ints\n",
       "    Array of indices into the array. It has the same shape as `a.shape`\n",
       "    with the dimension along `axis` removed.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "ndarray.argmax, argmin\n",
       "amax : The maximum value along a given axis.\n",
       "unravel_index : Convert a flat index into an index tuple.\n",
       "\n",
       "Notes\n",
       "-----\n",
       "In case of multiple occurrences of the maximum values, the indices\n",
       "corresponding to the first occurrence are returned.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> a = np.arange(6).reshape(2,3) + 10\n",
       ">>> a\n",
       "array([[10, 11, 12],\n",
       "       [13, 14, 15]])\n",
       ">>> np.argmax(a)\n",
       "5\n",
       ">>> np.argmax(a, axis=0)\n",
       "array([1, 1, 1])\n",
       ">>> np.argmax(a, axis=1)\n",
       "array([2, 2])\n",
       "\n",
       "Indexes of the maximal elements of a N-dimensional array:\n",
       "\n",
       ">>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)\n",
       ">>> ind\n",
       "(1, 2)\n",
       ">>> a[ind]\n",
       "15\n",
       "\n",
       ">>> b = np.arange(6)\n",
       ">>> b[1] = 5\n",
       ">>> b\n",
       "array([0, 5, 2, 3, 4, 5])\n",
       ">>> np.argmax(b)  # Only the first occurrence is returned.\n",
       "1\n",
       "\u001b[0;31mFile:\u001b[0m      ~/anaconda3/lib/python3.7/site-packages/numpy/core/fromnumeric.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.argmax?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excercise: the Trapezoidal rule\n",
    "\n",
    "**Illustrates**: basic array slicing, functions as first class objects.\n",
    "\n",
    "In this exercise, you are tasked with implementing the simple trapezoid\n",
    "rule formula for numerical integration that we illustrated above.\n",
    "\n",
    "\n",
    "If we denote by $x_{i}$ ($i=0,\\ldots,n,$ with $x_{0}=a$ and $x_{n}=b$) the abscissas\n",
    "where the function is sampled, then\n",
    "\n",
    "$$\\int_{a}^{b}f(x)dx\\approx\\frac{1}{2}\\sum_{i=1}^{n}\\left(x_{i}-x_{i-1}\\right)\\left(f(x_{i})+f(x_{i-1})\\right).$$\n",
    "\n",
    "The common case of using equally spaced abscissas with spacing $h=(b-a)/n$ reads:\n",
    "\n",
    "$$\\int_{a}^{b}f(x)dx\\approx\\frac{h}{2}\\sum_{i=1}^{n}\\left(f(x_{i})+f(x_{i-1})\\right).$$\n",
    "\n",
    "One frequently receives the function values already precomputed, $y_{i}=f(x_{i}),$ so the formula becomes\n",
    "\n",
    "$$\\int_{a}^{b}f(x)dx\\approx\\frac{1}{2}\\sum_{i=1}^{n}\\left(x_{i}-x_{i-1}\\right)\\left(y_{i}+y_{i-1}\\right).$$\n",
    "\n",
    "In this exercise, you'll need to write two functions, `trapz` and `trapzf`. `trapz` applies the trapezoid formula to pre-computed values, implementing equation trapz, while `trapzf` takes a function $f$ as input, as well as the total number of samples to evaluate, and computes the equation above.\n",
    "\n",
    "Test it and show that it produces correct values for some simple integrals you can compute analytically or compare your answers against `scipy.integrate.trapz` as above, using our test function $f(x)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operating with arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays support all regular arithmetic operators, and the numpy library also contains a complete collection of basic mathematical functions that operate on arrays.  It is important to remember that in general, all operations with arrays are applied *element-wise*, i.e., are applied to all the elements of the array at the same time.  Consider for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3] + [10 11 12 13] = [10 12 14 16]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.arange(4)\n",
    "arr2 = np.arange(10, 14)\n",
    "print(arr1, '+', arr2, '=', arr1+arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importantly, you must remember that even the multiplication operator is by default applied element-wise, it is *not* the matrix multiplication from linear algebra (as is the case in Matlab, for example):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3] * [10 11 12 13] = [ 0 11 24 39]\n"
     ]
    }
   ],
   "source": [
    "print(arr1, '*', arr2, '=', arr1*arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this means that in principle arrays must always match in their dimensionality in order for an operation to be valid, numpy will *broadcast* dimensions when possible.  For example, suppose that you want to add the number 1.5 to `arr1`; the following would be a valid way to do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.5, 2.5, 3.5, 4.5])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 + 1.5*np.ones(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But thanks to numpy's broadcasting rules, the following is equally valid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.5, 2.5, 3.5, 4.5])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 + 1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, numpy looked at both operands and saw that the first (`arr1`) was a one-dimensional array of length 4 and the second was a scalar, considered a zero-dimensional object. The broadcasting rules allow numpy to:\n",
    "\n",
    "* *create* new dimensions of length 1 (since this doesn't change the size of the array)\n",
    "* 'stretch' a dimension of length 1 that needs to be matched to a dimension of a different size.\n",
    "\n",
    "So in the above example, the scalar 1.5 is effectively:\n",
    "\n",
    "* first 'promoted' to a 1-dimensional array of length 1\n",
    "* then, this array is 'stretched' to length 4 to match the dimension of `arr1`.\n",
    "\n",
    "After these two operations are complete, the addition can proceed as now both operands are one-dimensional arrays of length 4.\n",
    "\n",
    "This broadcasting behavior is in practice enormously powerful, especially because when numpy broadcasts to create new dimensions or to 'stretch' existing ones, it doesn't actually replicate the data.  In the example above the operation is carried *as if* the 1.5 was a 1-d array with 1.5 in all of its entries, but no actual array was ever created.  This can save lots of memory in cases when the arrays in question are large and can have significant performance implications.\n",
    "\n",
    "The general rule is: when operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing dimensions, and works its way forward, creating dimensions of length 1 as needed. Two dimensions are considered compatible when\n",
    "\n",
    "* they are equal to begin with, or\n",
    "* one of them is 1; in this case numpy will do the 'stretching' to make them equal.\n",
    "\n",
    "If these conditions are not met, a `ValueError: operands could not be broadcast together with shapes ...` exception is thrown, indicating that the arrays have incompatible shapes. The size of the resulting array is the maximum size along each dimension of the input arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows how the broadcasting rules work in several dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3]\n",
      " [4 5 6 7]] \n",
      "\n",
      "+ [2 3 4 5] \n",
      "----------------\n",
      " [[ 2  4  6  8]\n",
      " [ 6  8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([2, 3, 4, 5])\n",
    "print(arr, '\\n\\n+', b , '\\n----------------\\n', arr + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, how could you use broadcasting to say add `[4, 6]` along the rows to `arr` above?  Simply performing the direct addition will produce the error we previously mentioned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,4) (2,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-154-295e9774345c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0marr\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,4) (2,) "
     ]
    }
   ],
   "source": [
    "c = np.array([4, 6])\n",
    "arr + c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to the rules above, the array `c` would need to have a *trailing* dimension of 1 for the broadcasting to work.  It turns out that numpy allows you to 'inject' new dimensions anywhere into an array on the fly, by indexing it with the special object `np.newaxis`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4],\n",
       "       [6]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,)\n",
      "(2, 1)\n"
     ]
    }
   ],
   "source": [
    "print(c.shape)\n",
    "print((c[:, np.newaxis]).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is exactly what we need, and indeed it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  5,  6,  7],\n",
       "       [10, 11, 12, 13]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr + c[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the full broadcasting rules, please see the official Numpy docs, which describe them in detail and with more complex examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading and writing arrays to disk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy lets you read and write arrays into files in a number of ways.  In order to use these tools well, it is critical to understand the difference between a *text* and a *binary* file containing numerical data.  In a text file, the number $\\pi$ could be written as \"3.141592653589793\", for example: a string of digits that a human can read, with in this case 15 decimal digits.  In contrast, that same number written to a binary file would be encoded as 8 characters (bytes) that are not readable by a human but which contain the exact same data that the variable `pi` had in the computer's memory.  \n",
    "\n",
    "The tradeoffs between the two modes are thus:\n",
    "\n",
    "* Text mode: occupies more space, precision can be lost (if not all digits are written to disk), but is readable and editable by hand with a text editor.  Can *only* be used for one- and two-dimensional arrays.\n",
    "\n",
    "* Binary mode: compact and exact representation of the data in memory, can't be read or edited by hand.  Arrays of any size and dimensionality can be saved and read without loss of information.\n",
    "\n",
    "First, let's see how to read and write arrays in text mode.  The `np.savetxt` function saves an array to a text file, with options to control the precision, separators and even adding a header:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# My dataset\n",
      "0.00e+00 1.00e+00 2.00e+00 3.00e+00 4.00e+00\n",
      "5.00e+00 6.00e+00 7.00e+00 8.00e+00 9.00e+00\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10).reshape(2, 5)\n",
    "np.savetxt('test.out', arr, fmt='%.2e', header=\"My dataset\")\n",
    "!cat test.out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And this same type of file can then be read with the matching `np.loadtxt` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1. 2. 3. 4.]\n",
      " [5. 6. 7. 8. 9.]]\n"
     ]
    }
   ],
   "source": [
    "arr2 = np.loadtxt('test.out')\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For binary data, Numpy provides the `np.save` and `np.savez` routines.  The first saves a single array to a file with `.npy` extension, while the latter can be used to save a *group* of arrays into a single file with `.npz` extension.  The files created with these routines can then be read with the `np.load` function.\n",
    "\n",
    "Let us first see how to use the simpler `np.save` function to save a single array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any differences? False\n"
     ]
    }
   ],
   "source": [
    "np.save('test.npy', arr2)\n",
    "# Now we read this back\n",
    "arr2n = np.load('test.npy')\n",
    "# Let's see if any element is non-zero in the difference.\n",
    "# A value of True would be a problem.\n",
    "print('Any differences?', np.any(arr2-arr2n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us see how the `np.savez` function works.  You give it a filename and either a sequence of arrays or a set of keywords.  In the first mode, the function will auotmatically name the saved arrays in the archive as `arr_0`, `arr_1`, etc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['arr_0', 'arr_1']"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.savez('test.npz', arr, arr2)\n",
    "arrays = np.load('test.npz')\n",
    "arrays.files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can explicitly choose how to name the arrays we save:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['array1', 'array2']"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.savez('test.npz', array1=arr, array2=arr2)\n",
    "arrays = np.load('test.npz')\n",
    "arrays.files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object returned by `np.load` from an `.npz` file works like a dictionary, though you can also access its constituent files by attribute using its special `.f` field; this is best illustrated with an example with the `arrays` object from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row of first array: [0 1 2 3 4]\n",
      "First row of first array: [0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print('First row of first array:', arrays['array1'][0])\n",
    "# This is an equivalent way to get the same field\n",
    "print('First row of first array:', arrays.f.array1[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `.npz` format is a very convenient way to package compactly and without loss of information, into a single file, a group of related arrays that pertain to a specific problem.  At some point, however, the complexity of your dataset may be such that the optimal approach is to use one of the standard formats in scientific data processing that have been designed to handle complex datasets, such as NetCDF or HDF5.  \n",
    "\n",
    "Fortunately, there are tools for manipulating these formats in Python, and for storing data in other ways such as databases.  A complete discussion of the possibilities is beyond the scope of this discussion, but of particular interest for scientific users we at least mention the following:\n",
    "\n",
    "* The `scipy.io` module contains routines to read and write Matlab files in `.mat` format and files in the NetCDF format that is widely used in certain scientific disciplines.\n",
    "\n",
    "* For manipulating files in the HDF5 format, there are two excellent options in Python: The PyTables project offers a high-level, object oriented approach to manipulating HDF5 datasets, while the h5py project offers a more direct mapping to the standard HDF5 library interface.  Both are excellent tools; if you need to work with HDF5 datasets you should read some of their documentation and examples and decide which approach is a better match for your needs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# High quality data visualization with Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [matplotlib](http://matplotlib.sf.net) library is a powerful tool capable of producing complex publication-quality figures with fine layout control in two and three dimensions; here we will only provide a minimal self-contained introduction to its usage that covers the functionality needed for the rest of the book.  We encourage the reader to read the tutorials included with the matplotlib documentation as well as to browse its extensive gallery of examples that include source code.\n",
    "\n",
    "Just as we typically use the shorthand `np` for Numpy, we will use `plt` for the `matplotlib.pyplot` module where the easy-to-use plotting functions reside (the library contains a rich object-oriented architecture that we don't have the space to discuss here):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most frequently used function is simply called `plot`, here is how you can make a simple plot of $\\sin(x)$ for $x \\in [0, 2\\pi]$ with labels and a grid (we use the semicolon in the last line to suppress the display of some information that is unnecessary right now):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 2*np.pi)\n",
    "y = np.sin(x)\n",
    "plt.figure()\n",
    "plt.plot(x,y, label='sin(x)')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.title('Harmonic')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can control the style, color and other properties of the markers, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y, linewidth=2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y, 'o', markersize=5, color='r');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now see how to create a few other common plot types, such as a simple error plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# example data\n",
    "x = np.arange(0.1, 4, 0.5)\n",
    "y = np.exp(-x)\n",
    "\n",
    "# example variable error bar values\n",
    "yerr = 0.1 + 0.2*np.sqrt(x)\n",
    "xerr = 0.1 + yerr\n",
    "\n",
    "# First illustrate basic pyplot interface, using defaults where possible.\n",
    "plt.figure()\n",
    "plt.errorbar(x, y, xerr=0.2, yerr=0.4)\n",
    "plt.title(\"Simplest errorbars, 0.2 in x, 0.4 in y\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple log plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-5, 5)\n",
    "y = np.exp(-x**2)\n",
    "plt.semilogy(x, y);\n",
    "#plt.plot(x, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A histogram annotated with text inside the plot, using the `text` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/arendta/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:5: MatplotlibDeprecationWarning: \n",
      "The 'normed' kwarg was deprecated in Matplotlib 2.1 and will be removed in 3.1. Use 'density' instead.\n",
      "  \"\"\"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mu, sigma = 100, 15\n",
    "x = mu + sigma * np.random.randn(10000)\n",
    "\n",
    "# the histogram of the data\n",
    "n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75)\n",
    "\n",
    "plt.xlabel('Smarts')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('Histogram of IQ')\n",
    "# This will put a text fragment at the position given:\n",
    "plt.text(55, .027, r'$\\mu=100,\\ \\sigma=15$', fontsize=14)\n",
    "plt.axis([40, 160, 0, 0.03])\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `imshow` command can display single or multi-channel images.  A simple array of random numbers, plotted in grayscale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import cm\n",
    "\n",
    "plt.imshow(np.random.rand(5, 10), cmap=cm.gray, interpolation='nearest');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A real photograph is a multichannel image, `imshow` interprets it correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensions of the array img: (247, 332, 4)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = plt.imread('img/stinkbug.png')\n",
    "print('Dimensions of the array img:', img.shape)\n",
    "plt.imshow(img);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple 3d plotting with matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you must execute at least once in your session:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One this has been done, you can create 3d axes with the `projection='3d'` keyword to `add_subplot`:\n",
    "\n",
    "    fig = plt.figure()\n",
    "    fig.add_subplot(<other arguments here>, projection='3d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple surface plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.mplot3d.axes3d import Axes3D\n",
    "from matplotlib import cm\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1, 1, 1, projection='3d')\n",
    "X = np.arange(-5, 5, 0.25)\n",
    "Y = np.arange(-5, 5, 0.25)\n",
    "X, Y = np.meshgrid(X, Y)\n",
    "R = np.sqrt(X**2 + Y**2)\n",
    "Z = np.sin(R)\n",
    "surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.viridis,\n",
    "        linewidth=0, antialiased=False)\n",
    "ax.set_zlim3d(-1.01, 1.01);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional Resources\n",
    "\n",
    "For Numpy, Matplotlib, SciPy and related tools, these resources will be particularly useful:\n",
    "\n",
    "* [Elegant SciPy](http://proquest.safaribooksonline.com/9781491922927), a collection of example-oriented lessons on how to best use the scientific Python toolkit, by the creator of Scikit-Image and BIDS researcher [Stéfan van der Walt](https://bids.berkeley.edu/people/st%C3%A9fan-van-der-walt). In addition to the previous O'Reilly reader, the [full book](https://github.com/elegant-scipy/elegant-scipy) as well as all the [notebooks](https://github.com/elegant-scipy/notebooks) are available.  \n",
    "\n",
    "* Stéfan has also written a [very useful notebook](https://github.com/stefanv/teaching/blob/master/2016_aspp_reading_numpy/numpy_advanced.ipynb) about semi-advanced aspects of Numpy, with a [companion problem set](https://github.com/stefanv/teaching/blob/master/2016_aspp_reading_numpy/numpy_advanced_problems.ipynb).\n",
    "\n",
    "* Nicolas Rougier has a great [introductory Numpy tutorial](http://www.labri.fr/perso/nrougier/teaching/numpy/numpy.html), an [advanced Numpy book](http://www.labri.fr/perso/nrougier/from-python-to-numpy) and a collection of (often subtle!) [Numpy exercises](http://www.labri.fr/perso/nrougier/teaching/numpy.100/index.html).\n",
    "\n",
    "* Jake VanderPlas' excellent [Python Data Science Handbook](https://github.com/jakevdp/PythonDataScienceHandbook) is freely available online.\n",
    "\n",
    "* The [online SciPy Lectures](http://www.scipy-lectures.org), and specifically for this topic, the [NumPy chapter](http://www.scipy-lectures.org/intro/numpy/index.html).\n",
    "\n",
    "* The [official Numpy documentation](https://docs.scipy.org/doc/numpy-1.13.0/index.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional libraries\n",
    "The four 'core' libraries covered in this notebook are in practice complemented by a number of other tools for more specialized work.  We will briefly list here the ones that we think are the most commonly needed:\n",
    "\n",
    "* **Sympy:** a symbolic manipulation tool that turns a Python session into a computer algebra system.  It integrates with the IPython notebook, rendering results in properly typeset mathematical notation.  [sympy.org](http://sympy.org).\n",
    "\n",
    "* **Mayavi:** sophisticated 3d data visualization; [code.enthought.com/projects/mayavi](http://code.enthought.com/projects/mayavi).\n",
    "\n",
    "* **Cython:** a bridge language between Python and C, useful both to optimize performance bottlenecks in Python and to access C libraries directly; [cython.org](http://cython.org).\n",
    "\n",
    "* **Pandas:** high-performance data structures and data analysis tools, with powerful data alignment and structural manipulation capabilities; [pandas.pydata.org](http://pandas.pydata.org).\n",
    "\n",
    "* **Statsmodels:** statistical data exploration and model estimation; [statsmodels.sourceforge.net](http://statsmodels.sourceforge.net).\n",
    "\n",
    "* **Scikit-learn:** general purpose machine learning algorithms with a common interface; [scikit-learn.org](http://scikit-learn.org).\n",
    "\n",
    "* **Scikits-image:** image processing toolbox; [scikits-image.org](http://scikits-image.org).\n",
    "\n",
    "* **NetworkX:** analysis of complex networks (in the graph theoretical sense); [networkx.lanl.gov](http://networkx.lanl.gov).\n",
    "\n",
    "* **PyTables:** management of hierarchical datasets using the industry-standard HDF5 format; [www.pytables.org](http://www.pytables.org).\n",
    "\n",
    "Beyond these, for any specific problem you should look on the internet first, before starting to write code from scratch.  There's a good chance that someone, somewhere, has written an open source library that you can use for part or all of your problem."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
